home *** CD-ROM | disk | FTP | other *** search
/ Over 1,000 Windows 95 Programs / Over 1000 Windows 95 Programs (Microforum) (Disc 1).iso / 1257 / staclist.cp_ / staclist.cp
Encoding:
Text File  |  1997-04-18  |  5.0 KB  |  294 lines
  1. /* EasyCODE(C++) V5.1 01.03.1995 11:32:46
  2. Object classes "list" and "stack" */
  3. /* EasyCODE O
  4. If=horizontal
  5. LevelNumbers=no
  6. LineNumbers=no
  7. ScreenFont=System,,100,1,-13,0,700,0,0,0,0,0,0,1,2,1,34
  8. PrinterFont=Courier,,100,2,-42,0,400,0,0,0,0,0,0,2,1,2,49
  9. LastLevelId=32 */
  10.  
  11. /* EasyCODE ( 1
  12.    Stack/List */
  13. #include <iostream.h>
  14.  
  15. const int Max_elem = 10;
  16.  
  17. /* EasyCODE ( 2
  18.    Declaration of Class List */
  19.  
  20. /* EasyCODE C */
  21. class List
  22.    {
  23.    protected:
  24.       int *list;        // An integer array
  25.       int nmax;         // The dimension of the array
  26.       int nelem;        // The number of elements
  27.    public:
  28.  
  29.       /* EasyCODE ( 22
  30.          List */
  31.  
  32.       /* EasyCODE F */
  33.       List(int n = Max_elem)
  34.          {
  35.          list = new int[n]; nmax = n; nelem = 0;
  36.          }
  37.       /* EasyCODE ) */
  38.  
  39.       /* EasyCODE ( 21
  40.          ~List */
  41.  
  42.       /* EasyCODE F */
  43.       ~List()
  44.          {
  45.          delete list;
  46.          }
  47.       /* EasyCODE ) */
  48.  
  49.       /* EasyCODE ( 29
  50.          clear_list */
  51.  
  52.       /* EasyCODE F */
  53.       void clear_list()
  54.          {
  55.          for (int i = 0; i < nmax; i++)
  56.             {
  57.             list[i]=0;
  58.             }
  59.          }
  60.       /* EasyCODE ) */
  61.  
  62.       /* EasyCODE ( 5
  63.          setn */
  64.  
  65.       /* EasyCODE F */
  66.       void setn(int n)
  67.          {
  68.          nelem = n;
  69.          }
  70.       /* EasyCODE ) */
  71.  
  72.       /* EasyCODE ( 6
  73.          getn */
  74.  
  75.       /* EasyCODE F */
  76.       int getn()
  77.          {
  78.          return nelem;
  79.          }
  80.       /* EasyCODE ) */
  81.  
  82.       /* EasyCODE ( 7
  83.          incn */
  84.  
  85.       /* EasyCODE F */
  86.       void incn()
  87.          {
  88.          if (nelem < nmax)
  89.             {
  90.             ++nelem;
  91.             }
  92.          }
  93.       /* EasyCODE ) */
  94.  
  95.       /* EasyCODE ( 8
  96.          getmax */
  97.  
  98.       /* EasyCODE F */
  99.       int getmax()
  100.          {
  101.          return nmax;
  102.          }
  103.       /* EasyCODE ) */
  104.       int put_elem(int, int);
  105.       /* EasyCODE - */
  106.       int get_elem(int&, int);
  107.       /* EasyCODE - */
  108.       virtual void print();
  109.    };
  110. /* EasyCODE E */
  111. /* EasyCODE ) */
  112.  
  113. /* EasyCODE ( 9
  114.    Declaration of Class Stack */
  115.  
  116. /* EasyCODE C */
  117. class Stack : public List
  118.    {
  119.       int top;
  120.    public:
  121.  
  122.       /* EasyCODE ( 10
  123.          Stack */
  124.  
  125.       /* EasyCODE F */
  126.       Stack()
  127.          {
  128.          top = 0;
  129.          }
  130.       /* EasyCODE ) */
  131.  
  132.       /* EasyCODE ( 11
  133.          Stack */
  134.  
  135.       /* EasyCODE F */
  136.       Stack(int n) : List(n)
  137.          {
  138.          top = 0;
  139.          }
  140.       /* EasyCODE ) */
  141.       int push(int elem);
  142.       /* EasyCODE - */
  143.       int pop(int& elem);
  144.       /* EasyCODE - */
  145.       void print();
  146.    };
  147. /* EasyCODE E */
  148. /* EasyCODE ) */
  149.  
  150. /* EasyCODE ( 19
  151.    Implementation of Class List */
  152.  
  153. /* EasyCODE ( 12
  154.    List::put_elem */
  155.  
  156. /* EasyCODE F */
  157. int List::put_elem(int elem, int pos)
  158.    {
  159.    if (0 <= pos && pos < nmax)
  160.       {
  161.       list[pos] = elem;
  162.       return 0;
  163.       }
  164.    else
  165.       {
  166.       return -1;
  167.       }
  168.    }
  169. /* EasyCODE ) */
  170.  
  171. /* EasyCODE ( 13
  172.    List::get_elem */
  173.  
  174. /* EasyCODE F */
  175. int List::get_elem(int& elem, int pos)
  176.    {
  177.    if (0 <= pos && pos < nmax)
  178.       {
  179.       elem = list[pos];
  180.       return 0;
  181.       }
  182.    else
  183.       {
  184.       return -1;
  185.       }
  186.    }
  187. /* EasyCODE ) */
  188.  
  189. /* EasyCODE ( 14
  190.    List::print */
  191.  
  192. /* EasyCODE F */
  193. void List::print()
  194.    {
  195.    for (int i = 0; i < nelem; ++i)
  196.       {
  197.       cout << list[i] << "\n";
  198.       }
  199.    }
  200. /* EasyCODE ) */
  201. /* EasyCODE ) */
  202.  
  203. /* EasyCODE ( 20
  204.    Implementation of Class Stack */
  205.  
  206. /* EasyCODE ( 15
  207.    Stack::push */
  208.  
  209. /* EasyCODE F */
  210. int Stack::push(int elem)
  211.    {
  212.    if (top < nmax)
  213.       {
  214.       list[top++] = elem;
  215.       return 0;
  216.       }
  217.    else
  218.       {
  219.       return -1;
  220.       }
  221.    }
  222. /* EasyCODE ) */
  223.  
  224. /* EasyCODE ( 16
  225.    Stack::pop */
  226.  
  227. /* EasyCODE F */
  228. int Stack::pop(int& elem)
  229.    {
  230.    if (top > 0)
  231.       {
  232.       elem = list[--top];
  233.       return 0;
  234.       }
  235.    else
  236.       {
  237.       return -1;
  238.       }
  239.    }
  240. /* EasyCODE ) */
  241.  
  242. /* EasyCODE ( 17
  243.    Stack::print */
  244.  
  245. /* EasyCODE F */
  246. void Stack::print()
  247.    {
  248.    for (int i = top-1; i >= 0; --i)
  249.       {
  250.       cout << list[i] << "\n";
  251.       }
  252.    }
  253. /* EasyCODE ) */
  254. /* EasyCODE ) */
  255.  
  256. /* EasyCODE ( 18
  257.    Main program */
  258.  
  259. /* EasyCODE F */
  260. main()
  261.    {
  262.    Stack s(5);
  263.    List l, *lp;
  264.    int i = 0;
  265.    
  266.    // Write numbers into the stack until stack is full
  267.    while (s.push(i+1) == 0)
  268.       {
  269.       ++i;
  270.       }
  271.    // Initialize list with Null values
  272.    l.clear_list();
  273.    /* EasyCODE - */
  274.    // Write a few numbers into the list
  275.    l.put_elem(1,0);
  276.    l.put_elem(2,3);
  277.    l.put_elem(3,4);
  278.    l.put_elem(4,7);
  279.    l.put_elem(5,9);
  280.    l.setn(l.get_max());
  281.    /* EasyCODE - */
  282.    // Stack output to screen
  283.    cout << "Stack:\n";
  284.    lp = &s;           
  285.    lp->print();       // Stack-print()
  286.    /* EasyCODE - */
  287.    // List output to screen
  288.    cout << "\nList:\n";
  289.    lp = &l;
  290.    lp->print();       // List-print()
  291.    }
  292. /* EasyCODE ) */
  293. /* EasyCODE ) */
  294.